Register comparison for operand store compare (osc) prediction

ABSTRACT

Embodiments relate to register comparison for register comparison for operand store compare (OSC) prediction. An aspect includes, for each instruction in an instruction group of a processor pipeline: determining a base register value of the instruction; determining an index register value of the instruction; and determining a displacement of the instruction. Another aspect includes comparing the base register value, index register value, and displacement of each instruction in the instruction group to the base register value, index register value, and displacement of all other instructions in the instruction group. Another aspect includes based on the comparison, determining that a load instruction of the instruction group has a probable OSC conflict with a store instruction of the instruction group. Yet another aspect includes delaying the load instruction based on the determined probable OSC conflict.

BACKGROUND

This invention relates generally to operand store compare (OSC)prediction, and more particularly to register comparison for OSCprediction.

As computer system designers seek to continually improve processorperformance, it is beneficial to develop approaches that reduce cyclesper instruction (CPI). Operand store compare (OSC) penalties can be alarge contributor to high CPI numbers. OSC is defined as encountering aninstruction with an operand to store data to memory followed by aninstruction to load the same data from the memory before the stored dataactually reaches the memory. As a stream of instructions progressesthrough a processor pipeline, various control units perform tasks suchas fetching instructions, dispatching instructions, calculating addressvalues, accessing registers, fetching operands, executing instructions,checking for error conditions, and retiring the instructions includingstoring the results. When instructions advance deeper through thepipeline, dependency conditions, conflicts, incorrectly predictedbranches, and the like, can stall progress of the instructions throughthe pipeline as the conditions are handled. A problem with OSC is thatoccurrence of the condition is unknown until a cache address is formed,which may be after the instruction has already been dispatched,requiring costly stall/reset mechanisms. For instance, when load store(LS) logic detects an OSC, it then rejects/recycles the load instructionand holds it from dispatching again until the storage data reaches apoint where it can be bypassed (or read) by the load instruction. Thepenalty of such a reject can be many (e.g., 9) cycles of unusedprocessing time. Compilers that generate the instructions typically tryto distance instructions that store and load the same data sufficientlyto minimize the OSC penalty. However, if the distance between the storeand load is not large enough, the load can still be rejected in theprocessor pipeline. The distance between two instructions is defined bythe number of cycles between dispatches of the two instructions. Thedistance is zero if the store and load are grouped and dispatchedtogether, for instance, in a super-scalar architecture.

SUMMARY

Embodiments include a method, system, and computer program product forregister comparison for operand store compare (OSC) prediction. Anaspect includes, for each instruction in an instruction group of aprocessor pipeline: determining a base register value of theinstruction; determining an index register value of the instruction; anddetermining a displacement of the instruction. Another aspect includescomparing the base register value, index register value, anddisplacement of each instruction in the instruction group to the baseregister value, index register value, and displacement of all otherinstructions in the instruction group. Another aspect includes based onthe comparison, determining that a load instruction of the instructiongroup has a probable OSC conflict with a store instruction of theinstruction group. Yet another aspect includes delaying the loadinstruction based on the determined probable OSC conflict.

BRIEF DESCRIPTION OF THE DRAWINGS

The subject matter which is regarded as embodiments is particularlypointed out and distinctly claimed in the claims at the conclusion ofthe specification. The forgoing and other features, and advantages ofthe embodiments are apparent from the following detailed descriptiontaken in conjunction with the accompanying drawings in which:

FIG. 1 depicts a system for register compare for OSC prediction inaccordance with an embodiment;

FIG. 2 depicts a processor pipeline, delay logic, and recycle queue forregister comparison for OSC prediction in accordance with an embodiment;

FIG. 3 depicts instruction formats in accordance with an embodiment;

FIG. 4 depicts further instruction formats in accordance with anembodiment; and

FIG. 5 depicts a process flow for register comparison for OSC predictionin accordance with an embodiment.

DETAILED DESCRIPTION

Embodiments of register comparison for OSC prediction are provided, withexemplary embodiments being discussed below in detail. Identification ofprobable OSC conflicts relatively early in the pipeline using registercomparison reduces associated delays. Register comparison for OSCprediction does not require additional memory for storing accumulatedinstruction history, but rather takes advantage of access to instructiontext as it moves through pipeline stages. At decode time, the baseregister, index register, and displacement of each instruction currentlyin the pipeline are compared to one another, allowing detection of OSCconflicts independent of instruction format. For each instruction thatdoes not have a base register and/or index register value defined, thebase register and/or index register value for that instruction may beset to a default value, such as zero, for purposes of the comparison,such that instructions in any format may be compared to one another topredict probable OSC conflicts. The terms base register value and indexregister value, as used herein, refer to the identifier of a referencedGeneral Purpose Register (GPR), and not to the contents of the GPR. Thisregister value is a 4 bit field in the instruction text sometimes calledthe register number. In various embodiments of register comparison forOSC prediction, all of the instructions, including all load and storeinstructions, in an instruction group in the pipeline are compared toeach other, regardless of instruction format. Further, in someembodiments, instructions may be compared across different instructiongroups.

OSC is also referred to as Store Hit Load (SHL), and relates todependency on memory data between a store and a load instruction. Thereare dynamic and static techniques for predicting OSC conflicts. Dynamictechniques use a table of addresses that have had prior OSC conflicts,while static techniques have no history of prior executions and onlyutilize recent decoded instruction text. Embodiments of registercomparison for OSC prediction implement static prediction of probableOSC conflicts. In some embodiments, the prediction is suppressed basedon decoding of a prediction override instruction in between the load andstore. The static OSC prediction technique may sometimes need to beoverridden by a programmer, so the override instruction is provided todisable OSC prediction if an override is located in the instructionstream in between the store and the load that may have a probable OSCconflict.

Loads and stores with common fields may be compared to each other asdescribed in U.S. Pat. No. 7,975,130 (Alexander et al., filed Feb. 20,2008, which is herein incorporated by reference in its entirety), butthis may not catch all the possible combinations of loads and stores.Some instructions may utilize an instruction format with more fieldsthan needed. Therefore, all register-based fetch and store operandspecifying instruction formats may be compared to detect OSC conflictsusing register based comparison. In some embodiments, data from any ofpositions 8 to 47 in an instruction, which may include a length fieldand operand fields, may be used in the comparison.

Register comparison for OSC prediction treats all loads and storesalike, and compares a base register field (B), an index register field(X), and a displacement field (D) of each instruction at dispatch time.For instruction formats that do not have some of these fields, theabsent fields are assumed to be a default value such as zero. Theinstruction text is created in the G1 cycle, then in the G2 cycle anystore and load instructions, independent of whether they have acompatible instruction format, are compared. A generic compare is donefor all stores and all loads using the B, X, and D fields. This mayresult in relatively fast timing of the circuits and cover a relativelylarge number of instruction formats.

In some embodiments, the low bits of the displacement field may bemasked for the comparison to detect the case of a not exact overlapbetween instructions. For example, masking may apply to decimal data inmemory when the sign digit of the data may be manipulated withoutmodifying the whole number. Additional logic may mask the lower fourbits of the displacements in two instructions that are being compared ifeither, but not both, of the load or the store accesses exactly one byteof storage. For example, masking may be required to compare a one bytestore character instruction (STC) with a displacement of xx5 against afour byte load L with a displacement of xx4. The compare knows, based onthe opcode of the STC, that the STC instruction accesses exactly onebyte. If both the STC and the L have the same B and X fields in theirrespective instruction text (itext), then, in this example, the STC isdirected to storage location 5 while L is directed to storage locations4, 5, 6, and 7. If the lower 4 bits of L are not masked (or, in thisspecific case, the lowest bit only), then the compare would incorrectlyfail since the displacements differ despite the actual storage accessedby each overlapping. However, because it is known that the STC accessesexactly one byte of storage and the L accesses additional storagelocations, both displacements are masked to xx0 before comparison,allowing the OSC issue between STC and L to be detected by thecomparison. In various embodiments, the lowest 4 bits of thedisplacement may be masked; in other embodiments, any appropriate numberof lowest bits of the displacement may be masked.

In another example, an instruction that uses signed-packed decimalformat holds the sign in the rightmost nibble in the rightmost byte, andoften only the sign is modified. Therefore, the displacement is maskedwhen comparing a packed-decimal instruction accessing exactly one byteagainst another instruction that accesses more than one byte. In thisexample, for the sign-packed decimal operation, the length must beexamined to know that the instruction only accesses one byte. In variousembodiments, if one of the load or the store accesses that are beingcompared are directed to exactly one byte but the other is not, thelower four bits of the displacement should be masked to increase theodds of the OSC comparison successfully detecting any OSC conflicts.

Turning now to FIG. 1, a system is depicted that includes multiplefunctional units to support pipelining of instructions in a computerprocessor 100. The processor 100 is part of a computer system comprisingthe processor 100 and a main memory 150 that is in communication withthe processor 100. Pipelining can increase instruction executionthroughput by performing stages such as fetching, decoding, executionand completion concurrently for multiple instructions in an instructionstream. In an exemplary embodiment, functional units in the processor100 include: instruction decoder 102, instruction grouping 104,instruction dispatcher 106, address generator 108, load store unit 110,and execution unit 112. It will be understood that additional functionalunits can be included in the processor 100 which are not depicted, suchas an instruction fetching unit, a completion unit, a recovery unit, andthe like. Multiple communication paths can be used to communicatebetween each of the functional units 102-112. The communication pathsmay vary in bus width (single-bit to multi-bit) and can beunidirectional or bidirectional. For example, path 114 passesinstruction text (itext) in an instruction stream from the instructiondecoder 102 to instruction grouping 104. The instruction grouping 104determines whether instructions can be grouped together for parallelprocessing, for example, using a super-scalar architecture. Theinstruction grouping 104 can create itext based OSC dependencies onolder store instructions that have progressed into later pipeline stages(e.g., in functional units 106-112). The instruction grouping 104 passesitext including any groups formed via path 116 to instruction dispatcher106. In an exemplary embodiment, the instruction dispatcher 106 delaysdispatching of a load instruction when a store instruction with apotential OSC condition has been identified. The instruction dispatcher106 dispatches itext, maintaining dependencies via path 118 to addressgenerator 108. The address generator 108 determines actual addressvalues, which may be calculated using a combination of base, index, anddisplacement fields from itext in the instruction stream. The addressgenerator 108 sends itext with operand address information to the loadstore unit 110 via path 120.

The load store unit 110 can access a data cache 122 via path 124 andreceives data from the data cache 122 via path 126. In an exemplaryembodiment, the load store unit 110 performs actual OSC detection,monitoring actual load and store accesses to the data cache 122. Whenthe load store unit 110 detects that an operand load has been requestedfor a location 140 in the data cache 122 that has not completed a storeoperation, the load store unit 110 declares a reject condition for theassociated instruction, since it cannot complete. The reject conditionis forwarded to execution unit 112 via path 128 and returned to addressgenerator 108 via path 130 and to instruction grouping 104 via path 132.Additionally, the load store unit 110 can feed information back to theaddress generator 108 via path 134, and forward information to theexecution unit 112 via path 136. The execution unit 112 can also senddata to the load store unit 110 via path 138 and send itext back to theinstruction grouping 104 via recycle path 140. Although the paths 130and 134, as well as paths 136 and 128, are depicted as separate paths,it will be understood that paths can be combined within the scope of theinvention.

Turning now to FIG. 2, a block diagram of an instruction stream in aprocessor pipeline 200 is depicted in accordance with an exemplaryembodiment. Stages of the processor pipeline 200 include D0 202 totransfer fetched instructions for decoding, D1 through D3 204 to decodeinstructions (e.g., instruction decoder 102 of FIG. 1), G1 205 and G2206 to group instructions (e.g., grouping stages in instruction grouping104 of FIG. 1), G3 208 to dispatch instructions (e.g., instructiondispatcher 106 of FIG. 1), AO 210 to perform address generation (e.g.,address generator 108 of FIG. 1), A1 through A3 212 for cache access(e.g., load store unit 110 of FIG. 1), A4 214 to execute instructions(e.g., execution stage 112 of FIG. 1), A5 216 to start the put away ofresults or recycle instructions on failure conditions, and A6 218 toretire instructions.

As instructions advance in decoding stages D1 through D3 204, aninstruction queue and address queue (IQ/AQ) 220 may be used to expanditext 224 into greater levels of detail for processing. The expansionadds additional control and status information associated with the itext224. Delay logic 226, which may also be referred to as dependencyforcing logic, monitors movement of the itext 224 into the G1 205 stageand identifies fields that may be used for operand address calculation.If a store instruction is identified, the delay logic 226 monitors for asubsequent load instruction with potential overlap in operand fieldsthat include operand address information. When an overlap is detected,the delay logic can hold the load instruction for up to a designatednumber of cycles to provide adequate time for the Store instruction toat least be able to support forwarding to a dependent Load. Delaying theLoad instruction proactively, rather than waiting for an actualnon-forwardable OSC to be detected later in the pipeline once addressgeneration is performed, prevents rejection of the load instruction.This Load to Store dependency tracking and stalling is applied for eachStore in the window of influence. The delay logic 226 may be performedin instruction decoder 102, instruction grouping 104, or instructiondispatcher 106 in FIG. 1. The instruction queue and address queue(IQ/AQ) 220 can be used to store decoded instruction text if thegrouping stages are blocked.

Recycle queue 222 retains instruction information for use in the caseswhere a retry of an instruction if necessary. Upon determining thatthere is a need to reject the dependent Load, the rejected instructionis returned to an earlier position in the processor pipeline 200 viarecycle path 228. In an exemplary embodiment, actual OSC rejects due toOSC occurs in A5 216.

When delay logic 226 forces a dependency between the store and the load,the load's issue is delayed until the store advances far enough inexecution that the store's data may be properly bypassed to the load toavoid an operand-store-compare (OSC) reject. Without the dependency theload may issue too quickly, resulting in the load being rejected andtaking longer to complete. The issuing of the load is delayed because ofthe forced dependency that is caused by delay logic 226.

Turning now to FIG. 3, some examples of instruction formats 300 aredepicted in accordance with various embodiments. Each row in theinstruction formats 300 includes instruction text (itext) formatting fora particular instruction format in the instruction formats 300. Fieldsare defined relative to bit positions. For example, bits positions 0 to7 represent opcodes 302. Bit positions 12 through 39 can contain operandaddress information 304 that may also include other informationdepending upon each instruction format. The operand address information304 may include operands for the opcodes 302, such as an index field306, a base field 308, a displacement field 310, and/or a highdisplacement field 316. The index field 306, base field 308,displacement field 310, and/or high displacement field 316 can becombined to form a value used to detect a potential OSC. The index andbase fields, 306 and 308, represent the number of a General PurposeRegister (GPR) to be utilized in Address generation. In cases whereeither field is not utilized by the instruction it is set to “0000”.Each format in the instructions formats 300 may provide formatting forboth load and store instructions. For example, the delay logic 226 ofFIG. 2 can identify load and store instructions formatted in RX format312. The identification and comparison of operand address information304 for load and store instructions can be performed across formats,such as a load instruction in RX format 312 and a store instruction inSI 314 format. The delay logic 226 may further compare any data from bitpositions 8 to 47, as needed, using register-based comparison.

FIG. 4 illustrates further examples of instruction formats 400 inaccordance with various embodiments. Each row in the instruction formats400 includes instruction text (itext) formatting for a particularinstruction format in the instruction formats 400. Fields are definedrelative to bit positions. For example, bits positions 0 to 7 representopcodes 402. Bit positions 12 through 31 can contain operand addressinformation 404 for a first memory operand that may also include otherinformation depending upon each instruction format. The operand addressinformation 404 may include operands for the opcodes 402, such as anindex field 406, a base field 408, and/or a displacement field 410. Theindex field 406, base field 408, and/or displacement field 410 can becombined to form a value used to detect a potential OSC. The index andbase fields, 406 and 408, represent the number of a GPR to be utilizedin address generation. In cases where either field is not utilized bythe instruction it is set to “0000”. Each format in the instructionsformats 400 may provide formatting for both load and store instructionsand may identify up to two memory operands. Bit positions 32 through 47may contain operand address information 416 for a second memory operandthat may also include other information depending upon each instructionformat. The second operand address information 416 may include a basefield 412 and/or a displacement field 414. The base field 412 and/ordisplacement field 414 can be combined to form a value used to detect apotential OSC. The base field 412 represent the number of a GPR to beutilized in address generation. For second operand address there is noindex field utilized by the instruction and it is set to “0000”. Thedelay logic 226 of FIG. 2 can identify load and store instructionsformatted in any of the formats listed in FIG. 4 and directly comparethe operand address information 404 and/or 416 associated with eachinstruction, a subset of fields (e.g., base fields 408) or a combinationof fields to detect a potential OSC. The identification and comparisonof operand address information 404 and/or 416 for load and storeinstructions can be performed across formats. The delay logic 226 mayfurther compare any data from bit positions 8 to 47, as required, usingregister-based comparison.

FIG. 5 illustrates an embodiment of a method 500 for register based OSCprediction. Embodiments of method 500 of FIG. 5 may be implemented inembodiments of delay logic 226 of FIG. 2. First, in block 501, the baseregister value B, index register value X, and displacement D areextracted from each of the load instructions and store instructions inan instruction group at decode time in a processor pipeline. The loadand store instructions may be in any of the instruction formats 300 and400 shown in FIGS. 3-4. Next, in block 502, if any of the load or storeinstructions in the instruction group do not have a base register valueB, the base register value B for the instruction(s) that does not have abase register value B is set equal to a default value such as zero. Inblock 503, if any of the load or store instructions in the instructiongroup do not have an index register value X, the index register value Xfor the instruction(s) that does not have an index register value X isset equal to a default value such as zero. In block 504, in someembodiments, a number of the lowest order bits of the displacement D aremasked in the load and store instructions of the instruction group. Insome embodiments, the lowest 4 bits of the displacement are masked. Thelowest bits of the displacement may be masked based on a determinationof an amount of data targeted by a store instruction; for example, astore instruction may only target a single byte of data, such that themasking allows comparison of the store instruction to a load instructionthat targets more bytes of data. In some embodiments, the length fieldsof the store instructions in the instruction group are checked todetermine the amount of data being stored, so as to determine whethermasking is needed. In some embodiments of method 500, block 504 may beomitted. In block 505, the B, X, and D values for each of the load andstore instructions in the instruction group are compared to each other,with any modifications that were made in blocks 502-504, and it isdetermined whether there are any OSC conflicts in the instruction groupbased on the comparison. In block 506, if it was determined in block 505that there is a probable OSC conflict between a load and a storeinstruction in the instruction group based on the comparison of block505, the load instruction that has the OSC conflict is delayed asdescribed above with respect to FIG. 2. Method 500 may be repeated ineach cycle by delay logic 226 for each instruction group that proceedsthrough the pipeline.

In further embodiments of blocks 505-506 of method 500, instructions maybe compared across instruction groups. An instruction group refers tohow instructions are tracked together for exceptions, or to a number ofinstructions that are dispatched in the same cycle. In an example, aninstruction group may be 3 instructions, and 6 instructions (or 2instruction groups) may be dispatched per cycle. Instructions may becompared across instruction groups and across multiple cycles. Forexample, stores may be active in the core for multiple cycles;therefore, register based OSC prediction may track active stores andcompare the active stores against new loads in different instructiongroups.

In some embodiments of method 500, encountering an override instructionin the instruction group that is located between a load and a store mayturn the comparison of the load and the store off, such that method 500is not performed for a load and a store that have an overrideinstruction located between them. The OSC prediction of method 500 issuppressed based detecting, at decode, of an override instruction inbetween the load and store. The static OSC prediction technique maysometimes need to be overridden by a programmer, so the overrideinstruction is provided to disable OSC prediction if an override islocated in the instruction stream in between the store and the load thatmay have a probable OSC conflict.

Technical effects and benefits include relatively fast OSC predictionindependent of instruction format.

The present invention may be a system, a method, and/or a computerprogram product. The computer program product may include a computerreadable storage medium (or media) having computer readable programinstructions thereon for causing a processor to carry out aspects of thepresent invention.

The computer readable storage medium can be a tangible device that canretain and store instructions for use by an instruction executiondevice. The computer readable storage medium may be, for example, but isnot limited to, an electronic storage device, a magnetic storage device,an optical storage device, an electromagnetic storage device, asemiconductor storage device, or any suitable combination of theforegoing. A non-exhaustive list of more specific examples of thecomputer readable storage medium includes the following: a portablecomputer diskette, a hard disk, a random access memory (RAM), aread-only memory (ROM), an erasable programmable read-only memory (EPROMor Flash memory), a static random access memory (SRAM), a portablecompact disc read-only memory (CD-ROM), a digital versatile disk (DVD),a memory stick, a floppy disk, a mechanically encoded device such aspunch-cards or raised structures in a groove having instructionsrecorded thereon, and any suitable combination of the foregoing. Acomputer readable storage medium, as used herein, is not to be construedas being transitory signals per se, such as radio waves or other freelypropagating electromagnetic waves, electromagnetic waves propagatingthrough a waveguide or other transmission media (e.g., light pulsespassing through a fiber-optic cable), or electrical signals transmittedthrough a wire.

Computer readable program instructions described herein can bedownloaded to respective computing/processing devices from a computerreadable storage medium or to an external computer or external storagedevice via a network, for example, the Internet, a local area network, awide area network and/or a wireless network. The network may comprisecopper transmission cables, optical transmission fibers, wirelesstransmission, routers, firewalls, switches, gateway computers and/oredge servers. A network adapter card or network interface in eachcomputing/processing device receives computer readable programinstructions from the network and forwards the computer readable programinstructions for storage in a computer readable storage medium withinthe respective computing/processing device.

Computer readable program instructions for carrying out operations ofthe present invention may be assembler instructions,instruction-set-architecture (ISA) instructions, machine instructions,machine dependent instructions, microcode, firmware instructions,state-setting data, or either source code or object code written in anycombination of one or more programming languages, including an objectoriented programming language such as Smalltalk, C++ or the like, andconventional procedural programming languages, such as the “C”programming language or similar programming languages. The computerreadable program instructions may execute entirely on the user'scomputer, partly on the user's computer, as a stand-alone softwarepackage, partly on the user's computer and partly on a remote computeror entirely on the remote computer or server. In the latter scenario,the remote computer may be connected to the user's computer through anytype of network, including a local area network (LAN) or a wide areanetwork (WAN), or the connection may be made to an external computer(for example, through the Internet using an Internet Service Provider).In some embodiments, electronic circuitry including, for example,programmable logic circuitry, field-programmable gate arrays (FPGA), orprogrammable logic arrays (PLA) may execute the computer readableprogram instructions by utilizing state information of the computerreadable program instructions to personalize the electronic circuitry,in order to perform aspects of the present invention

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer readable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof instructions, which comprises one or more executable instructions forimplementing the specified logical function(s). In some alternativeimplementations, the functions noted in the block may occur out of theorder noted in the figures. For example, two blocks shown in successionmay, in fact, be executed substantially concurrently, or the blocks maysometimes be executed in the reverse order, depending upon thefunctionality involved. It will also be noted that each block of theblock diagrams and/or flowchart illustration, and combinations of blocksin the block diagrams and/or flowchart illustration, can be implementedby special purpose hardware-based systems that perform the specifiedfunctions or acts or carry out combinations of special purpose hardwareand computer instructions.

The descriptions of the various embodiments of the present inventionhave been presented for purposes of illustration, but are not intendedto be exhaustive or limited to the embodiments disclosed. Manymodifications and variations will be apparent to those of ordinary skillin the art without departing from the scope and spirit of the describedembodiments. The terminology used herein was chosen to best explain theprinciples of the embodiments, the practical application or technicalimprovement over technologies found in the marketplace, or to enableothers of ordinary skill in the art to understand the embodimentsdisclosed herein.

1.-20. (canceled)
 21. A computer implemented method for registercomparison for operand store compare (OSC) prediction, the methodcomprising: for each instruction in an instruction group of a processorpipeline: determining a base register value of the instruction;determining an index register value of the instruction; and determininga displacement of the instruction; comparing the base register value,the index register value, and the displacement of each instruction inthe instruction group to the base register value the index registervalue, and the displacement of each other instruction in the instructiongroup; based on the comparison, determining that a load instruction ofthe instruction group has a probable OSC conflict with a storeinstruction of the instruction group; and delaying the load instructionbased on the determined probable OSC conflict.
 22. The method of claim21, wherein the load instruction is a first load instruction and thestore instruction is a first store instruction, the method furthercomprising: encountering a prediction override instruction locatedbetween a second load instruction and a second store instruction of theinstruction group; and turning off OSC prediction for the second loadinstruction and the second store instruction.
 23. The method of claim22, wherein the instruction group is a first instruction group, themethod further comprising: comparing the base register value, the indexregister value, and the displacement of each instruction in the firstinstruction group to a base register value, an index register value, anda displacement of each instruction in a second instruction group; anddetermining that the load instruction of the first instruction group hasa probable OSC conflict with a store instruction of the secondinstruction group; and delaying the load instruction based on thedetermined probable OSC conflict with the store instruction of thesecond instruction group.
 24. The method of claim 22, furthercomprising: determining that an instruction of the instruction groupdoes not have a base register value; and based on determining that theinstruction does not have a base register value, setting the baseregister value of the instruction equal to a default value for thecomparing.
 25. The method of claim 24, wherein the default value iszero.
 26. The method of claim 22, further comprising: determining thatan instruction of the instruction group does not have an index registervalue; and based on determining that the instruction does not have anindex register value, setting the index register value of theinstruction equal to a default value for the comparing.
 27. The methodof claim 26, wherein the default value is zero.
 28. The method of claim22, further comprising masking a set of lowest order bits of thedisplacement of each instruction before performing the comparing. 29.The method of claim 28, wherein a number of the set of lowest order bitsthat are masked is four.
 30. A computer program product for implementingregister comparison for operand store compare (OSC) prediction, thecomputer program product comprising: a computer readable storage mediumhaving program instructions embodied therewith, the program instructionsreadable by a processing circuit to cause the processing circuit toperform a method comprising: for each instruction in an instructiongroup of a processor pipeline: determining a base register value of theinstruction; determining an index register value of the instruction; anddetermining a displacement of the instruction; comparing the baseregister value, the index register value, and the displacement of eachinstruction in the instruction group to the base register value theindex register value, and the displacement of each other instruction inthe instruction group; based on the comparison, determining that a loadinstruction of the instruction group has a probable OSC conflict with astore instruction of the instruction group; and delaying the loadinstruction based on the determined probable OSC conflict.
 31. Thecomputer program product of claim 30, wherein the load instruction is afirst load instruction and the store instruction is a first storeinstruction, the method further comprising: encountering a predictionoverride instruction located between a second load instruction and asecond store instruction of the instruction group; and turning off OSCprediction for the second load instruction and the second storeinstruction.
 32. The computer program product of claim 31, wherein theinstruction group is a first instruction group, the method furthercomprising: comparing the base register value, the index register value,and the displacement of each instruction in the first instruction groupto a base register value, an index register value, and a displacement ofeach instruction in a second instruction group; and determining that theload instruction of the first instruction group has a probable OSCconflict with a store instruction of the second instruction group; anddelaying the load instruction based on the determined probable OSCconflict with the store instruction of the second instruction group. 33.The computer program product of claim 31, the method further comprising:determining that an instruction of the instruction group does not have abase register value; and based on determining that the instruction doesnot have a base register value, setting the base register value of theinstruction equal to a default value for the comparing.
 34. The computerprogram product of claim 31, the method further comprising: determiningthat an instruction of the instruction group does not have an indexregister value; and based on determining that the instruction does nothave an index register value, setting the index register value of theinstruction equal to a default value for the comparing.
 35. The computerprogram product of claim 31, the method further comprising masking a setof lowest order bits of the displacement of each instruction beforeperforming the comparing.
 36. A computer system for register comparisonfor operand store compare (OSC) prediction, the system comprising: amemory storing computer-executable instructions; and a processor,communicatively coupled to said memory, the processor configured toexecute the computer-executable instructions to perform a methodcomprising: for each instruction in an instruction group of a processorpipeline: determining a base register value of the instruction;determining an index register value of the instruction; and determininga displacement of the instruction; comparing the base register value,the index register value, and the displacement of each instruction inthe instruction group to the base register value the index registervalue, and the displacement of each other instruction in the instructiongroup; based on the comparison, determining that a load instruction ofthe instruction group has a probable OSC conflict with a storeinstruction of the instruction group; and delaying the load instructionbased on the determined probable OSC conflict.
 37. The system of claim36, wherein the load instruction is a first load instruction and thestore instruction is a first store instruction, the method furthercomprising: encountering a prediction override instruction locatedbetween a second load instruction and a second store instruction of theinstruction group; and turning off OSC prediction for the second loadinstruction and the second store instruction.
 38. The system of claim37, wherein the instruction group is a first instruction group, themethod further comprising: comparing the base register value, the indexregister value, and the displacement of each instruction in the firstinstruction group to a base register value, an index register value, anda displacement of each instruction in a second instruction group; anddetermining that the load instruction of the first instruction group hasa probable OSC conflict with a store instruction of the secondinstruction group; and delaying the load instruction based on thedetermined probable OSC conflict with the store instruction of thesecond instruction group.
 39. The system of claim 37, the method furthercomprising: determining that an instruction of the instruction groupdoes not have a base register value; and based on determining that theinstruction does not have a base register value, setting the baseregister value of the instruction equal to a default value for thecomparing.
 40. The system of claim 37, the method further comprising:determining that an instruction of the instruction group does not havean index register value; and based on determining that the instructiondoes not have an index register value, setting the index register valueof the instruction equal to a default value for the comparing.